package KK.net
{
	import KK.net.Command.CommandID;
	import KK.net.Data.Head;
	import KK.net.Proxy.*;
	
	import Protocol.EProtocol;
	
	import flash.utils.ByteArray;
	
	import mx.core.Singleton;

	public class ProxyManager
	{
		
		
		/**
		 * 初始化列表 
		 * @return 
		 * 
		 */
		private function get initFunctionManager():Vector.<Function>{
			var result:Vector.<Function>=new Vector.<Function>(EProtocol.EProtocol_Max,true);
			
			return result;
		}
		
		/**
		 * 初始化代理类 
		 * @return 
		 * 
		 */
		private function get initProxyClass():Vector.<IProxy>{
			var result:Vector.<IProxy>=new Vector.<IProxy>();
			
			return result;
		}
		
		
		/**
		 * 初始发送网络 
		 * @return 
		 * 
		 */
		private function get initProgressList():Vector.<Function>{
			var result:Vector.<Function>=new Vector.<Function>(CommandID.IC_MAX,true);
			return result;
		}
		
		private var ProgressList:Vector.<Function>=initProgressList;
		private var CommandList:Vector.<Function>=initFunctionManager;//命令处理函数
		private var ProxyList:Vector.<IProxy>=initProxyClass;//功能代理类代理类
		

		private static var instance:ProxyManager;
		public function ProxyManager(singleton:Singleton)
		{
			if(instance){
				throw new Error("创建失败 ,请使用Instance 获取单例");
			}
			instance=this;
			
			init();
		}
		
		
		
		/**
		 * 
		 * 初始化  
		 * 
		 */
		private function init():void{
			
			
			//////////////////////////////////////////////
			 
			
			ProxyManager.RegisterProxy(LoginProxy);
			ProxyManager.RegisterProxy(ErrorProxy);
			ProxyManager.RegisterProxy(UserProxy);
			
		}
		
		/**
		 * 添加代理类 
		 * @param proxy
		 * 
		 */
		private function addProxy(proxy:IProxy):void{
			ProxyList.push(proxy);
		}
		
		/**
		 * 注册类 
		 * @param proxy
		 * 
		 */
		protected function registerProxy(proxy:Class):void{
			try{
				ProxyList.push(new proxy);
			}catch(e:*){
				LogError("创建失败，所注册的 类非proxy");
			}
		}
		
		
		/**
		 * 添加命令处理 
		 * @param ID
		 * @param proxy
		 * 
		 */
		protected function registerCommand(ID:int,proxy:Function):void{
			CommandList[ID]=proxy; 
		}
		
		/**
		 * 注册内部处理  
		 * @param ID
		 * @param proxy
		 * 
		 */
		protected function registerProgress(ID:int,proxy:Function ):void{
			ProgressList[ID]=proxy;
		}
		/**
		 * 处理消息
		 * @param head
		 * @param data
		 * 
		 */
		protected function ProgressMessage(head:Head,data:ByteArray):void{
			LogInfo("收取包 ID:",head.protocolID);
			data.position=0;
			CommandList[head.protocolID]&&CommandList[head.protocolID](data);
		}
		
		/**
		 * 处理发送消息  
		 * @param id
		 * 
		 */
		protected function Progress(id:int):void{
			ProgressList[id]&&ProgressList[id]();
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		/**
		 * 添加代理  
		 * @param proxy
		 * 
		 */
		static public function RegisterProxy(proxy:Class):void{
			Instance.registerProxy(proxy);
		}
		
		
		/**
		 * 注册网络消息 处理对象  
		 * @param ID
		 * @param proxy
		 * 
		 */
		static public function RegisterCommand(ID:int,proxy:Function):void{
			Instance.registerCommand(ID,proxy);
		}
		/**
		 * 注册内部消息 处理  
		 * @param ID
		 * @param proxy
		 * 
		 */
		static public function RegisterProgress(ID:int,proxy:Function):void{
			Instance.registerProgress(ID,proxy);
		}
		
		/**
		 * 处理网络消息函数  
		 * @param head
		 * @param byte
		 * 
		 */
		static public function OnMessage(head:Head,byte:ByteArray):void{
			Instance.ProgressMessage(head,byte);
		}
		
		/**
		 * 处理内部发送消息  
		 * @param id
		 * 
		 */
		static public function OnProgress(id:int):void{
			Instance.Progress(id);
		}
		 
		/**
		 * 获取单例 
		 * @return 
		 * 
		 */
		static public function get Instance():ProxyManager{
			if(!instance){
				new ProxyManager(new Singleton);
			}
			return instance;
		}
		
	}
}

class Singleton{
	
}